# [十五] Spring MVC和嵌入式Tomcat

	@HandlesTypes(WebApplicationInitializer.class)
	public class SpringServletContainerInitializer implements ServletContainerInitializer {

	@Override
	public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext)
			throws ServletException {
		// 需要初始化的 WebApplicationInitializer类型的容器
		List<WebApplicationInitializer> initializers = new LinkedList<>();
		// 所有实现了 @HandlesTypes 注解中 WebApplicationInitializer接口类型的类
		if (webAppInitializerClasses != null) {
			for (Class<?> waiClass : webAppInitializerClasses) {
				// Be defensive: Some servlet containers provide us with invalid classes,
				// no matter what @HandlesTypes says...
				// 如果 这些实现类不是接口、不是抽象类、并且是 WebApplicationInitializer的子类
				if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
						WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
					try {
						// 通过反射示例化，并添加到初始化容器中
						initializers.add((WebApplicationInitializer)
								ReflectionUtils.accessibleConstructor(waiClass).newInstance());
					}
					catch (Throwable ex) {
						throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
					}
				}
			}
		}

		if (initializers.isEmpty()) {
			servletContext.log("No Spring WebApplicationInitializer types detected on classpath");
			return;
		}

		servletContext.log(initializers.size() + " Spring WebApplicationInitializers detected on classpath");
		AnnotationAwareOrderComparator.sort(initializers);
		// 实例化完成后，循环调用 onStartup 方法
		for (WebApplicationInitializer initializer : initializers) {
			initializer.onStartup(servletContext);
		}
	}

}

	public interface WebApplicationInitializer {
	// Tomcat 启动最终会执行其实现类中的 onStartup 方法
	void onStartup(ServletContext servletContext) throws ServletException;

}

	@Override
	public void onStartup(ServletContext servletContext) throws ServletException {
		// 在父类中完成了实例化 listener 的工作
		super.onStartup(servletContext);
		// 注册实例化 DispatcherServlet
		registerDispatcherServlet(servletContext);
	}

	@Override
	public void onStartup(ServletContext servletContext) throws ServletException {
		registerContextLoaderListener(servletContext);
	}
	
	protected void registerContextLoaderListener(ServletContext servletContext) {
		//创建 spring上下文，注册了 SpringContainer
		WebApplicationContext rootAppContext = createRootApplicationContext();
		if (rootAppContext != null) {
		   /*
			*  TODO : 创建监听器，取代 web.xml中的这种配置:
			* <listener>
			* 	  <listener-class>
			* 	  org.springframework.web.context.ContextLoaderListener
			* 	  </listener-class>
			* </listener>
			*
			* */
			ContextLoaderListener listener = new ContextLoaderListener(rootAppContext);
			listener.setContextInitializers(getRootApplicationContextInitializers());
			// 把监听器添加到 servlet 上下文中
			servletContext.addListener(listener);
		}
		else {
			logger.debug("No ContextLoaderListener registered, as " +
					"createRootApplicationContext() did not return an application context");
		}
	}
	

protected WebApplicationContext createRootApplicationContext() {
		// 返回AbstractAnnotationConfigDispatcherServletInitializer子类中重写
		// 的getRootConfigClasses方法，该方法通常使用 @ComponentScan负责扫描加载
		// 的扫描配置类(父容器)，也就是扫描不包括 @Controller注解的类，钩子方法
		Class<?>[] configClasses = getRootConfigClasses();
		if (!ObjectUtils.isEmpty(configClasses)) {
			AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
			// 配置类不为空，则注册到上下文
			context.register(configClasses);
			return context;
		}
		else {
			return null;
		}
	}

/**
 *  TODO : 注册实例化 DispatcherServlet，取代 Web.xml中的配置
 */
protected void registerDispatcherServlet(ServletContext servletContext) {
		String servletName = getServletName();
		Assert.hasLength(servletName, "getServletName() must not return null or empty");
		//创建 springmvc的上下文，注册了 MvcContainer类
		WebApplicationContext servletAppContext = createServletApplicationContext();
		Assert.notNull(servletAppContext, "createServletApplicationContext() must not return null");
		// 创建 DispatcherServlet
		FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);
		Assert.notNull(dispatcherServlet, "createDispatcherServlet(WebApplicationContext) must not return null");
		dispatcherServlet.setContextInitializers(getServletApplicationContextInitializers());

		ServletRegistration.Dynamic registration = servletContext.addServlet(servletName, dispatcherServlet);
		if (registration == null) {
			throw new IllegalStateException("Failed to register servlet with name '" + servletName + "'. " +
					"Check if there is another servlet registered under the same name.");
		}
		/*
		* 	如果该元素的值为负数或者没有设置，则容器会当Servlet被请求时再加载。
		* 	如果值为正整数或者0时，表示容器在应用启动时就加载并初始化这个servlet，
		* 	值越小，servlet的优先级越高，就越先被加载
		* */
		registration.setLoadOnStartup(1);
		registration.addMapping(getServletMappings());
		registration.setAsyncSupported(isAsyncSupported());

		Filter[] filters = getServletFilters();
		if (!ObjectUtils.isEmpty(filters)) {
			for (Filter filter : filters) {
				registerServletFilter(servletContext, filter);
			}
		}

		customizeRegistration(registration);
	}

public boolean listenerStart() {
// ...... 省略	
for(int i = 0; i < instances.length; ++i) {
	if (instances[i] instanceof ServletContextListener) {
		ServletContextListener listener = (ServletContextListener)instances[i];
		try {
			this.fireContainerEvent("beforeContextInitialized", listener);
			if (this.noPluggabilityListeners.contains(listener)) {
				// 此处会调到 ContextLoaderListener 类的 		   
				// contextInitialized 方法， 完成 Spring 容器的启动
				listener.contextInitialized(tldEvent);
			} else {
				listener.contextInitialized(event);
			}
			this.fireContainerEvent("afterContextInitialized", listener);
		} catch (Throwable var12) {
			ExceptionUtils.handleThrowable(var12);
			this.fireContainerEvent("afterContextInitialized", listener);
			this.getLogger().error(sm.getString("standardContext.listenerStart", new Object[]{instances[i].getClass().getName()}), var12);
			ok = false;
		}
	}
}
// ...... 省略	
 }

public void contextInitialized(ServletContextEvent event) {
		// servlet 容器启动的时候会调用初始化方法，完成Spring容器的启动。
		initWebApplicationContext(event.getServletContext());
	}

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
		// ...... 省略		
		long startTime = System.currentTimeMillis();
		try {
			if (this.context == null) {
				this.context = createWebApplicationContext(servletContext);
			}
			if (this.context instanceof ConfigurableWebApplicationContext) {
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
				if (!cwac.isActive()) {
					if (cwac.getParent() == null) {
					ApplicationContext parent = loadParentContext(servletContext);
						cwac.setParent(parent);
					}
					// 启动 Spring 容器入口
					configureAndRefreshWebApplicationContext(cwac, servletContext);
				}
			}
// 把上下文对象设置到 servletContext 中
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
		// ...... 省略
	}

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
		// ...... 省略

		customizeContext(sc, wac);
		// 此处最终调用了 AbstractApplicationContext的 refresh 方法启动 
		// Spring容器， 也就是 Spring 容器启动最核心的方法，该监听器启动的Spring容器
    	// 将作为父容器，后面DispatchServlet启动的Spring容器是其子容器。
		wac.refresh();
	}

public final void init() throws ServletException {
		PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
		if (!pvs.isEmpty()) {
			try {
				BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
				ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
				bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
				initBeanWrapper(bw);
				bw.setPropertyValues(pvs, true);
			}
			catch (BeansException ex) {
				if (logger.isErrorEnabled()) {
					logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
				}
				throw ex;
			}
		}

		// 启动 DispatcherServlet 入口
		initServletBean();
	}

	@Override
	protected final void initServletBean() throwss ServletException {
	// 对应日志输出，说明开始 DispatcherServlet 初始化： 
	// INFO o.s.web.servlet.DispatcherServlet - Initializing Servlet 'dispatcher'
		if (logger.isInfoEnabled()) {
			logger.info("Initializing Servlet '" + getServletName() + "'");
		}
		long startTime = System.currentTimeMillis();

		try {
			// 启动 DispatcherServlet 入口
			this.webApplicationContext = initWebApplicationContext();
			initFrameworkServlet();
		}
		catch (ServletException | RuntimeException ex) {
			logger.error("Context initialization failed", ex);
			throw ex;
		}

	}

	protected WebApplicationContext initWebApplicationContext() {
		// 从 servletContext 中获取父容器
		WebApplicationContext rootContext =
	WebApplicationContextUtils.getWebApplicationContext(getServletContext());
		WebApplicationContext wac = null;
		if (this.webApplicationContext != null) {
			wac = this.webApplicationContext;
			if (wac instanceof ConfigurableWebApplicationContext) {
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
				if (!cwac.isActive()) {
					if (cwac.getParent() == null) {
						cwac.setParent(rootContext);
					}
					configureAndRefreshWebApplicationContext(cwac);
				}
			}
		}
		if (wac == null) {
			wac = findWebApplicationContext();
		}
		if (wac == null) {
			wac = createWebApplicationContext(rootContext);
		}

		if (!this.refreshEventReceived) {
			synchronized (this.onRefreshMonitor) {
				// 最终执行 onRefresh 方法完成 DispatcherServlet的启动
				onRefresh(wac);
			}
		}

		if (this.publishContext) {
			String attrName = getServletContextAttributeName();
			getServletContext().setAttribute(attrName, wac);
		}

		return wac;
	}

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
// 导入Spring MVC进行配置的一个代理类
@Import(DelegatingWebMvcConfiguration.class)
public @interface EnableWebMvc {
}

@Configuration
public class DelegatingWebMvcConfiguration extends WebMvcConfigurationSupport {

	private final WebMvcConfigurerComposite configurers = new WebMvcConfigurerComposite();

	@Autowired(required = false)
	public void setConfigurers(List<WebMvcConfigurer> configurers) {
		if (!CollectionUtils.isEmpty(configurers)) {
			this.configurers.addWebMvcConfigurers(configurers);
		}
	}
	
	// ...... 省略	
}

public class WebMvcConfigurationSupport implements ApplicationContextAware, ServletContextAware {
	@Bean
	public RequestMappingHandlerMapping requestMappingHandlerMapping() {
	// ...... 省略
	}
	@Bean
	public RequestMappingHandlerAdapter requestMappingHandlerAdapter() {
	// ...... 省略
	}
	@Bean
	@Nullable
	public HandlerMapping viewControllerHandlerMapping() {
		ViewControllerRegistry registry = new ViewControllerRegistry(this.applicationContext);
		addViewControllers(registry);

		AbstractHandlerMapping handlerMapping = registry.buildHandlerMapping();
		if (handlerMapping == null) {
			return null;
		}
		handlerMapping.setPathMatcher(mvcPathMatcher());
		handlerMapping.setUrlPathHelper(mvcUrlPathHelper());
		handlerMapping.setInterceptors(getInterceptors());
		handlerMapping.setCorsConfigurations(getCorsConfigurations());
		return handlerMapping;
	}
	// 添加拦截器钩子方法
	protected void addInterceptors(InterceptorRegistry registry) {
	}
	// 添加静态资源钩子方法
	protected void addResourceHandlers(ResourceHandlerRegistry registry) {
	}

}